#include<stdio.h>
/*
				memmove函数解析
参数解析：
	memmove 函数从 src 指向的内存空间拷贝 n 个字节到 dest 指向的内存空间。
	为了避免因为两个内存空间出现重叠而导致的悲剧，该函数会先将 src 指向的内存空间拷贝到一个临时的数组中，完了再从临时数组拷贝到目标内存空间。
	但是在一般情况下，使用memcpy效率会比memmove高效，除非你需要拷贝到统一数组中，否则不推荐使用memmove函数

函数原型：
	#include<string.h>
	...
	void *memmove(void *dest,const void *src,size_t n)

参数解析：
	参数：					含义：
	dest					指向目标的内存空间
	src						指向源内存空间	
	n						指定要拷贝的dest空间的前n个自己

返回值：
	返回dest指向的内存空间


参考文献：
	https://blog.csdn.net/weixin_72357342/article/details/134063243
	https://www.runoob.com/cprogramming/c-function-memmove.html



*/

//例子：
//使用memmove()函数完成拷贝整型数组数据(目的地与源重叠)
#if 0

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1 + 2, arr1, 20);


	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

#endif 


//使用memmove函数完成拷贝字符串数组(目的地和源重叠)
//使用memmove()函数将str数组的" very useful"拷贝到" useful......"的位置上去:
#if 0

/* memmove 使用测试 */
#include <stdio.h>
#include <string.h>

int main()
{
	char str[] = "memmove can be very useful......";
	memmove(str + 20, str + 15, 11);
	//使用memmove()函数拷贝内存块重叠字符串

	printf("%s\n", str);
	return 0;
}
#endif 

//模拟实现memmove函数

#if 1

#include<stdio.h>
#include<assert.h>


void* my_memmove(void* destination, const void* source, size_t num);


void* my_memmove(void* destination, const void* source, size_t num)
{

	assert(destination);
	assert(source);

	void* rec = destination;

	if (source < destination)
	{
		while (num--)
		{
			*((char*)destination + num) = *((char*)source + num);
		}
	}
	else
	{
		while (num--)
		{
			*(char*)destination = *(char*)source;
			destination = (char*)destination + 1;
			source = (char*)source + 1;

		}
	}
	return rec;
}


int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
#if 0
	//正序拷贝
	//3,4,5,6,7拷贝到1,2,3,4,5的位置上
	my_memmove(arr, arr + 2, sizeof(arr[0]) * 5);
#else
	// 逆序拷贝
	//将arr数组的1,2,3,4,5拷贝到3,4,5,6,7的位置上
	my_memmove(arr + 2, arr, sizeof(arr[0] * 5));

#endif

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
#endif 